/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package damas2;

import javax.swing.JButton;
import javax.swing.JOptionPane;

/**
 *
 * @author Alex
 */
public class Engine {
    private static Engine singleton;
    public Protocolo protocolo = new Protocolo();
    public Interface inter = null;
    public IA ia = new IA();
    private char[][] tabuleiro = new char[8][8]; //0 a 7 = 8 casas do tabuleiro
    private boolean origem;
    static JButton btnOrigem;
    public Vizinho[][] viz = new Vizinho[8][100]; // Matriz que guarda a linha e a coluna da origem e destino
    private String[] vetorCaminho = new String[4]; // Array que guarda,String, os possiveis caminhos a serem feitos
    int k=0;

public class Vizinho {
    public int linha;
    public int coluna;
    public int linha_adv;
    public int coluna_adv;

    public Vizinho(){
        linha = -1;
        coluna = -1;
        linha_adv = -1;
        coluna_adv = -1;
    }
}

    public Engine(){
        Inicializa_tabuleiro();
        iniciaMatrizLogica(tabuleiro);
        protocolo = new Protocolo();
        //protocolo.Receber_tabuleiro(tabuleiro);
        //formataJogada(tabuleiro);
        origem  = false;

    }

    public char[][] getTabuleiro() {
        return tabuleiro;
    }

    public void setTabuleiro(char[][] tabuleiro) {
        this.tabuleiro = tabuleiro;
    }


    public static Engine getInstance(){
    if (singleton == null) {
	singleton = new Engine();
    }
    return singleton;}

    private  void Inicializa_tabuleiro() {
        //Peças Brancas
        Interface.jButton00.setIcon(Interface.azul.getIcon());
        Interface.jButton02.setIcon(Interface.azul.getIcon());
        Interface.jButton04.setIcon(Interface.azul.getIcon());
        Interface.jButton06.setIcon(Interface.azul.getIcon());
        Interface.jButton11.setIcon(Interface.azul.getIcon());
        Interface.jButton13.setIcon(Interface.azul.getIcon());
        Interface.jButton15.setIcon(Interface.azul.getIcon());
        Interface.jButton17.setIcon(Interface.azul.getIcon());
        Interface.jButton20.setIcon(Interface.azul.getIcon());
        Interface.jButton22.setIcon(Interface.azul.getIcon());
        Interface.jButton24.setIcon(Interface.azul.getIcon());
        Interface.jButton26.setIcon(Interface.azul.getIcon());
        //Peças pretas
        Interface.jButton51.setIcon(Interface.vrmelha.getIcon());
        Interface.jButton53.setIcon(Interface.vrmelha.getIcon());
        Interface.jButton55.setIcon(Interface.vrmelha.getIcon());
        Interface.jButton57.setIcon(Interface.vrmelha.getIcon());
        Interface.jButton60.setIcon(Interface.vrmelha.getIcon());
        Interface.jButton62.setIcon(Interface.vrmelha.getIcon());
        Interface.jButton64.setIcon(Interface.vrmelha.getIcon());
        Interface.jButton66.setIcon(Interface.vrmelha.getIcon());
        Interface.jButton71.setIcon(Interface.vrmelha.getIcon());
        Interface.jButton73.setIcon(Interface.vrmelha.getIcon());
        Interface.jButton75.setIcon(Interface.vrmelha.getIcon());
        Interface.jButton77.setIcon(Interface.vrmelha.getIcon());
        //Casas vazias
        Interface.jButton31.setIcon(Interface.vazio.getIcon());
        Interface.jButton33.setIcon(Interface.vazio.getIcon());
        Interface.jButton35.setIcon(Interface.vazio.getIcon());
        Interface.jButton37.setIcon(Interface.vazio.getIcon());
        Interface.jButton40.setIcon(Interface.vazio.getIcon());
        Interface.jButton42.setIcon(Interface.vazio.getIcon());
        Interface.jButton44.setIcon(Interface.vazio.getIcon());
        Interface.jButton46.setIcon(Interface.vazio.getIcon());

    }

    public  void Habilita_tabuleiro(boolean SET){
        Interface.jButton00.setEnabled(SET);
        Interface.jButtonBranco01.setEnabled(SET);
        Interface.jButton02.setEnabled(SET);
        Interface.jButtonBranco03.setEnabled(SET);
        Interface.jButton04.setEnabled(SET);
        Interface.jButtonBranco05.setEnabled(SET);
        Interface.jButton06.setEnabled(SET);
        Interface.jButtonBranco07.setEnabled(SET);
        Interface.jButtonBranco10.setEnabled(SET);
        Interface.jButton11.setEnabled(SET);
        Interface.jButtonBranco12.setEnabled(SET);
        Interface.jButton13.setEnabled(SET);
        Interface.jButtonBranco14.setEnabled(SET);
        Interface.jButton15.setEnabled(SET);
        Interface.jButtonBranco16.setEnabled(SET);
        Interface.jButton17.setEnabled(SET);
        Interface.jButton20.setEnabled(SET);
        Interface.jButtonBranco21.setEnabled(SET);
        Interface.jButton22.setEnabled(SET);
        Interface.jButtonBranco23.setEnabled(SET);
        Interface.jButton24.setEnabled(SET);
        Interface.jButtonBranco25.setEnabled(SET);
        Interface.jButton26.setEnabled(SET);
        Interface.jButtonBranco27.setEnabled(SET);
        Interface.jButtonBranco30.setEnabled(SET);
        Interface.jButton31.setEnabled(SET);
        Interface.jButtonBranco32.setEnabled(SET);
        Interface.jButton33.setEnabled(SET);
        Interface.jButtonBranco34.setEnabled(SET);
        Interface.jButton35.setEnabled(SET);
        Interface.jButtonBranco36.setEnabled(SET);
        Interface.jButton37.setEnabled(SET);
        Interface.jButton40.setEnabled(SET);
        Interface.jButtonBranco41.setEnabled(SET);
        Interface.jButton42.setEnabled(SET);
        Interface.jButtonBranco43.setEnabled(SET);
        Interface.jButton44.setEnabled(SET);
        Interface.jButtonBranco45.setEnabled(SET);
        Interface.jButton46.setEnabled(SET);
        Interface.jButtonBranco47.setEnabled(SET);
        Interface.jButtonBranco50.setEnabled(SET);
        Interface.jButton51.setEnabled(SET);
        Interface.jButtonBranco52.setEnabled(SET);
        Interface.jButton53.setEnabled(SET);
        Interface.jButtonBranco54.setEnabled(SET);
        Interface.jButton55.setEnabled(SET);
        Interface.jButtonBranco56.setEnabled(SET);
        Interface.jButton57.setEnabled(SET);
        Interface.jButton60.setEnabled(SET);
        Interface.jButtonBranco61.setEnabled(SET);
        Interface.jButton62.setEnabled(SET);
        Interface.jButtonBranco63.setEnabled(SET);
        Interface.jButton64.setEnabled(SET);
        Interface.jButtonBranco65.setEnabled(SET);
        Interface.jButton66.setEnabled(SET);
        Interface.jButtonBranco67.setEnabled(SET);
        Interface.jButtonBranco70.setEnabled(SET);
        Interface.jButton71.setEnabled(SET);
        Interface.jButtonBranco72.setEnabled(SET);
        Interface.jButton73.setEnabled(SET);
        Interface.jButtonBranco74.setEnabled(SET);
        Interface.jButton75.setEnabled(SET);
        Interface.jButtonBranco76.setEnabled(SET);
        Interface.jButton77.setEnabled(SET);
    }

    public void VerificaVencedor(){

        int branca = 0;
        int preta = 0;
        int damabranca = 0;
        int damapreta = 0;


        for (int i=0;i<tabuleiro.length;i++){
            for(int j = 0;j<tabuleiro[i].length;j++){
                if ( tabuleiro[i][j] == 'b')
                    branca ++;

                else if (tabuleiro[i][j] == 'p')
                    preta ++;

                    else if (tabuleiro[i][j] == 'P')
                        damapreta ++;

                        else if (tabuleiro[i][j] == 'B')
                            damabranca ++;
            }
        }

        if ((preta == 0)&& (damapreta == 0)){
            JOptionPane.showMessageDialog(null, "Você Ganhou!");
            Habilita_tabuleiro(false);
        }

        if ((branca == 0) && (damabranca == 0)){
            JOptionPane.showMessageDialog(null, "Que pena, você perdeu!");
            Habilita_tabuleiro(false); }


        if (
           ((damabranca == 2) && (damapreta == 2)) ||
           ((damabranca == 2) && (damapreta == 1)) ||
           ((damabranca == 1) && (damapreta == 2)) ||
           ((damabranca == 2) && (damapreta == 1) && (preta == 1)) ||
           ((damabranca == 1) && (branca == 1) && (damapreta == 2))
           ) {
                JOptionPane.showMessageDialog(null, "O jogo empatou!");
                Habilita_tabuleiro(false); }

        /* Falta fazer uma varialvel contador de jogada pra definir mais um tipo de empate*/

    }

    private void iniciaMatrizLogica(char[][] matriz){
    /* Peça branca = b
     * Dama branca = B
     * Peça preta =  p
     * Dama preta =  P
     * Sem peça   =  x
     */
        for (int i=0;i<matriz.length;i++)
            for(int j = 0;j<matriz[i].length;j++)
                if (((i == 0) && (j==0)) || ((i == 2) && (j==0))
                 || ((i == 1) && (j==1))
                 || ((i == 0) && (j==2)) || ((i == 2) && (j==2))
                 || ((i == 1) && (j==3))
                 || ((i == 0) && (j==4)) || ((i == 2) && (j==4))
                 || ((i == 1) && (j==5))
                 || ((i == 0) && (j==6)) || ((i == 2) && (j==6))
                 || ((i == 1) && (j==7))
                 )
                    matriz[i][j] = 'b';
                else if(((i == 6) && (j==0))
                || ((i == 5) && (j==1)) || ((i == 7) && (j==1))
                || ((i == 6) && (j==2))
                || ((i == 5) && (j==3)) || ((i == 7) && (j==3))
                || ((i == 6) && (j==4))
                || ((i == 5) && (j==5)) || ((i == 7) && (j==5))
                || ((i == 6) && (j==6))
                || ((i == 5) && (j==7)) || ((i == 7) && (j==7))
                )
                    matriz[i][j] = 'p';
                else matriz[i][j] = 'x';
    }

    /*Método que verifica qual o destino do movimento*/
    /*Temos 4 casos a considerar:
     1 - Movimento para diagonal inferior direita :  destLin < orLin
                                                     destCol > orCol
     2 - Movimento para diagonal inferior esquerda:  destLin < orLin
                                                     destCol < orCol
     3 - Movimento para diagonal superior direita :  destLin > orLin
                                                     destCol > orCol
     4 - Movimento para diagonal superior esquerda : destLin > orLin
                                                     destCol < orCol
     -1: Problema*/

    private int destMovimento(int orLin,int destLin ,int orCol, int destCol){
        if (destLin < orLin && destCol > orCol){    //Caso 1
            return 1;
        }
        else{
            if (destLin < orLin && destCol < orCol){         //Caso 2
                return 2;
            }
            else{
                 if (destLin > orLin && destCol > orCol){         //Caso 3
                     return 3;
                 }
                 else{
                      if (destLin > orLin && destCol < orCol){         //Caso 4
                          return 4;
                      }
                 }
            }
       }
       return -1; //Problema
    }


    /**Método que verifica se há alguma casa preenchida na
     diagonal do movimento da dama, envia o número de casas já preenchidas */

    private int verificaPecaDiagonal(int orLin,int destLin ,int orCol, int destCol, char[][] tablog){
        int count = 0;
        int j = orCol;
        if (destMovimento(orLin,destLin,orCol,destCol) == 1){
            for (int i = orLin-1;i>=destLin;i--){
                j++;
                if (tablog[i][j] != 'x'){
                    count++;
                } 
            }
            return count;
        }
        else {
              if (destMovimento(orLin,destLin,orCol,destCol) == 2){
                  for (int i = orLin-1;i>=destLin;i--){
                      j--;
                      if (tablog[i][j] != 'x'){
                          count++;
                      }     
                  }
                  return count;
              }
              else {
                    if (destMovimento(orLin,destLin,orCol,destCol) == 3){
                        for (int i = orLin+1;i<=destLin;i++){
                            j++;
                            if (tablog[i][j] != 'x'){
                                count++;
                            } 
                        }
                    return count;
                    }
                    else {
                          if (destMovimento(orLin,destLin,orCol,destCol) == 4){
                              for (int i = orLin+1;i<=destLin;i++){
                                  j--;
                                  if (tablog[i][j] != 'x'){
                                      count++;
                                  }
                              }
                          return count;
                          }
                    }
              }
        }
        return count;
    }

    /*Só retorna TRUE quando o movimento foi realizado com SUCESSO*/

    public boolean Move(JButton botao){
     /*Temos 3 casos de movimento a se considerar:
     *Meio
     *Laterais
     *Fim do tabuleiro(tem que reverter os movimentos)*/   
        int linha = Integer.parseInt(botao.getName().substring(7, 8));
        int coluna = Integer.parseInt(botao.getName().substring(8, 9));  //Retirei a verificação se é branco, pq não precisa já que os
        tabuleiro = getTabuleiro();
        if (tabuleiro[linha][coluna] != 'p' && tabuleiro[linha][coluna] != 'P'){
        if ((!origem) && (tabuleiro[linha][coluna] != 'x'))                //botões brancos não tem evento de click de mouse
        {                                                               //mas isso gera uma inconsistência...
            origem = true;                                              //era pra peça perder o realce e recomeçar, como no caso de uma casa inválida
            btnOrigem = botao;
            if (tabuleiro[linha][coluna] == 'B'){
            botao.setIcon(Interface.damaAzulRealce.getIcon());}
            else{
            botao.setIcon(Interface.azulRealce.getIcon());}
           // protocolo.Enviar_tabuleiro(tabuleiro);
           // protocolo.Receber_tabuleiro(tabuleiro);
            return false;                                               //Início de movimento
        }
        else if((tabuleiro[linha][coluna] == 'x') && origem)  //Fica redundante, mas se tirar fica com bug
             {
                int destLin = Integer.parseInt(botao.getName().substring(7, 8));       //Renomeio de novo pra ficar mais legível
                int destCol = Integer.parseInt(botao.getName().substring(8, 9));       //Renomeio de novo pra ficar mais legível
                int origemLin = Integer.parseInt(btnOrigem.getName().substring(7, 8));
                int origemCol = Integer.parseInt(btnOrigem.getName().substring(8, 9));
                origem = false;
                if (!(tabuleiro[origemLin][origemCol] == 'B')){
                    if ((destLin>origemLin) && ((destCol==origemCol-1) || (destCol==origemCol+1))){
                        if (btnOrigem != botao){
                            botao.setIcon(Interface.azul.getIcon());
                            tabuleiro[destLin][destCol] =  tabuleiro[origemLin][origemCol];
                            tabuleiro[origemLin][origemCol] = 'x';
                            //protocolo.Enviar_tabuleiro(tabuleiro);
                            //protocolo.Receber_tabuleiro(tabuleiro);
                            btnOrigem.setIcon(Interface.vazio.getIcon());
                            System.out.println("Movimento do peão realizado com sucesso! ☺");
                            return true;                                                 //Movimento realizado com sucesso
                        } else {origem = false;
                                btnOrigem.setIcon(Interface.azul.getIcon());
                                btnOrigem = new JButton();
                                botao = new JButton();
                                //protocolo.Enviar_tabuleiro(tabuleiro);
                                //protocolo.Receber_tabuleiro(tabuleiro);
                                System.out.println("Clicou no mesmo botão(Origem) ☻");        //Soh pra debugg
                                return false;                                               //Acabou o movimento pois clicou no mesmo botão 
                                }
                    } else {
                         if (((destLin>origemLin) && (destLin<=origemLin+2)) && ((destCol==origemCol-2) || (destCol==origemCol+2))){ //Entra no método de comer da Gabi
                            if (btnOrigem != botao){
                                if (destMovimento(origemLin,destLin,origemCol,destCol) == 3){ //Movimento para diagonal superior direita
                                    if ((tabuleiro[origemLin+1][origemCol+1] == 'p') || (tabuleiro[origemLin+1][origemCol+1] == 'P')){
                                        Captura(btnOrigem, botao);}
                                    else{
                                        System.out.println("Jogada apenas permitida se houver peça para se comer");
                                        btnOrigem.setIcon(Interface.azul.getIcon());
                                        return false;
                                    }
                                }
                                else{//Não come para trás(por enquanto)
                                     if (destMovimento(origemLin,destLin,origemCol,destCol) == 1){ //Movimento para diagonal inferior direita
                                        if ((tabuleiro[origemLin-1][origemCol+1] == 'p') || (tabuleiro[origemLin-1][origemCol+1] == 'P')){
                                            Captura(btnOrigem, botao);}
                                        else{
                                            System.out.println("Jogada apenas permitida se houver peça para se comer");
                                            btnOrigem.setIcon(Interface.azul.getIcon());
                                            return false;
                                        }
                                     }
                                     else {
                                           if (destMovimento(origemLin,destLin,origemCol,destCol) == 4){ //Movimento para diagonal superior esquerda
                                               if ((tabuleiro[origemLin+1][origemCol-1] == 'p') || (tabuleiro[origemLin+1][origemCol-1] == 'P')){
                                                    Captura(btnOrigem, botao);}
                                                else{
                                                    System.out.println("Jogada apenas permitida se houver peça para se comer");
                                                    btnOrigem.setIcon(Interface.azul.getIcon());
                                                    return false;
                                        }
                                           }
                                           else{//Não come para trás(por enquanto)
                                                 if (destMovimento(origemLin,destLin,origemCol,destCol) == 2){ //Movimento para diagonal inferior esquerda
                                                     if ((tabuleiro[origemLin-1][origemCol-1] == 'p') || (tabuleiro[origemLin-1][origemCol-1] == 'P')){
                                                           Captura(btnOrigem, botao);}
                                                      else{
                                                           System.out.println("Jogada apenas permitida se houver peça para se comer");
                                                           btnOrigem.setIcon(Interface.azul.getIcon());
                                                           return false;
                                                      }
                                                 }
                                           }
                                     }
                                }
                            }
                         } else{
                                origem = false;
                                btnOrigem.setIcon(Interface.azul.getIcon());
                                btnOrigem = new JButton();
                                botao = new JButton();
                                //protocolo.Enviar_tabuleiro(tabuleiro);
                                //protocolo.Receber_tabuleiro(tabuleiro);
                                System.out.println("Jogou em casa não permitida! ☻");          //Soh pra debugg
                                return false;                                                //Acabou o movimento pois jogou em casa não permitida
                            }}
                }
                else {
                      if((destLin!=origemLin) && (destCol!=origemCol) && (verificaPecaDiagonal(origemLin,destLin,origemCol,destCol, tabuleiro) == 0)){
                                if (btnOrigem != botao){                                                                        
                                    botao.setIcon(Interface.damaAzul.getIcon());
                                    tabuleiro[destLin][destCol] =  tabuleiro[origemLin][origemCol];
                                    tabuleiro[origemLin][origemCol] = 'x';
                                    btnOrigem.setIcon(Interface.vazio.getIcon());
                                    //protocolo.Enviar_tabuleiro(tabuleiro);
                                    //protocolo.Receber_tabuleiro(tabuleiro);
                                    System.out.println("Movimento da dama realizado com sucesso! ☺");
                                    return true;                                                 //Movimento da dama realizado com sucesso
                                }else {origem = false;
                                        btnOrigem.setIcon(Interface.damaAzul.getIcon());
                                        btnOrigem = new JButton();
                                        botao = new JButton();
                                        //protocolo.Enviar_tabuleiro(tabuleiro);
                                        //protocolo.Receber_tabuleiro(tabuleiro);
                                        System.out.println("Dama - Clicou no mesmo botão(Origem) ☻");//Soh pra debugg
                                        return false;                                               //Acabou o movimento pois clicou no mesmo botão 
                                }
                         }else {
                                if (verificaPecaDiagonal(origemLin,destLin,origemCol,destCol, tabuleiro) == 1){
                                    if (destMovimento(origemLin,destLin,origemCol,destCol) == 1){
                                        if (tabuleiro[destLin+1][destCol-1] == 'p' || tabuleiro[destLin+1][destCol-1] == 'P'){
                                            Captura(btnOrigem, botao);}
                                        else{
                                            System.out.println("Dama não pode comer dessa maneira");
                                            btnOrigem.setIcon(Interface.damaAzul.getIcon());
                                            return false;
                                        }
                                    }
                                    else{
                                        if (destMovimento(origemLin,destLin,origemCol,destCol) == 2){
                                            if (tabuleiro[destLin+1][destCol+1] == 'p' || tabuleiro[destLin+1][destCol+1] == 'P'){
                                                Captura(btnOrigem, botao);}
                                            else{
                                                System.out.println("Dama não pode comer dessa maneira");
                                                btnOrigem.setIcon(Interface.damaAzul.getIcon());
                                                return false;
                                            }
                                        }
                                        else{
                                            if (destMovimento(origemLin,destLin,origemCol,destCol) == 3){
                                                if (tabuleiro[destLin-1][destCol-1] == 'p' || tabuleiro[destLin-1][destCol-1] == 'P'){
                                                    Captura(btnOrigem, botao);}
                                                else{
                                                    System.out.println("Dama não pode comer dessa maneira");
                                                    btnOrigem.setIcon(Interface.damaAzul.getIcon());
                                                    return false;
                                                }
                                            }
                                            else{
                                                if (destMovimento(origemLin,destLin,origemCol,destCol) == 4){
                                                    if (tabuleiro[destLin-1][destCol+1] == 'p' || tabuleiro[destLin-1][destCol+1] == 'P'){
                                                        Captura(btnOrigem, botao);}
                                                    else{
                                                        System.out.println("Dama não pode comer dessa maneira");
                                                        btnOrigem.setIcon(Interface.damaAzul.getIcon());
                                                        return false;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                else{
                                    origem = false;
                                    btnOrigem.setIcon(Interface.damaAzul.getIcon());
                                    btnOrigem = new JButton();
                                    botao = new JButton();
                                    //protocolo.Enviar_tabuleiro(tabuleiro);
                                    //protocolo.Receber_tabuleiro(tabuleiro);
                                    System.out.println("Dama - Jogou em casa não permitida ☻");     //Soh pra debugg
                                    return false;                                                //Acabou o movimento pois jogou em casa não permitida
                                }
                          }
                     }
        } else if (tabuleiro[linha][coluna] != 'x'){
                                int origemLin = Integer.parseInt(btnOrigem.getName().substring(7, 8));
                                int origemCol = Integer.parseInt(btnOrigem.getName().substring(8, 9));
                                if (tabuleiro[origemLin][origemCol] == 'B'){
                                    origem = false;
                                    btnOrigem.setIcon(Interface.damaAzul.getIcon());
                                    btnOrigem = new JButton();
                                    botao = new JButton();
                                    //protocolo.Enviar_tabuleiro(tabuleiro);
                                    //protocolo.Receber_tabuleiro(tabuleiro);
                                    System.out.println("Dama - Casa já preenchida ☻");                                 //Soh pra debugg
                                    return false;}
                                else{
                                    origem = false;
                                    btnOrigem.setIcon(Interface.azul.getIcon());
                                    btnOrigem = new JButton();
                                    botao = new JButton();
                                    //protocolo.Enviar_tabuleiro(tabuleiro);
                                    //protocolo.Receber_tabuleiro(tabuleiro);
                                    System.out.println("Casa já preenchida ☻");                                 //Soh pra debugg
                                    return false;}
                }                                                          //Acabou pois jogou em casa já preenchida
              else {
                    btnOrigem = new JButton();
                    botao = new JButton();
                    //protocolo.Enviar_tabuleiro(tabuleiro);
                    //protocolo.Receber_tabuleiro(tabuleiro);
                    System.out.println("Clicou na Origem! ☻");                                  //Soh pra debugg
                    return false;                                                              //Acabou pois clicou na origem
                    }
      return true;}
        else
            return false;
    }



    public void Virar_Dama (JButton peca){
        int linha = Integer.parseInt(peca.getName().substring(7, 8));
        int coluna = Integer.parseInt(peca.getName().substring(8, 9));
        if  ( (linha == 7) && (tabuleiro[linha][coluna] == 'b') ) {
            tabuleiro[linha][coluna] = 'B';
            peca.setIcon(Interface.damaAzul.getIcon());
        }
        else if ( (linha == 0) && (tabuleiro[linha][coluna] == 'p') ) {
            tabuleiro[linha][coluna] = 'P';
            peca.setIcon(Interface.damaVermelha.getIcon());
        }
    }

/*Solução idiota mas a única que pensei(SIM, pensei no case mas como são 2 comparações achei inviável)*/
    
private JButton setBotao(int i, int j){         //retorna null se não está em nenhum dos casos
    if((i == 0) && (j==0))
       return Interface.jButton00;
    if((i == 0) && (j==2))
       return Interface.jButton02;
    if((i == 0) && (j==4))
       return Interface.jButton04;
    if((i == 0) && (j==6))
       return Interface.jButton06;
    if((i == 1) && (j==1))
       return Interface.jButton11;
    if((i == 1) && (j==3))
       return Interface.jButton13;
    if((i == 1) && (j==5))
       return Interface.jButton15;
    if((i == 1) && (j==7))
       return Interface.jButton17;
    if((i == 2) && (j==0))
       return Interface.jButton20;
    if((i == 2) && (j==2))
       return Interface.jButton22;
    if((i == 2) && (j==4))
       return Interface.jButton24;
    if((i == 2) && (j==6))
       return Interface.jButton26;
    if((i == 3) && (j==1))
       return Interface.jButton31;
    if((i == 3) && (j==3))
       return Interface.jButton33;
    if((i == 3) && (j==5))
       return Interface.jButton35;
    if((i == 3) && (j==7))
       return Interface.jButton37;
    if((i == 4) && (j==0))
       return Interface.jButton40;
    if((i == 4) && (j==2))
       return Interface.jButton42;
    if((i == 4) && (j==4))
       return Interface.jButton44;
    if((i == 4) && (j==6))
       return Interface.jButton46;
    if((i == 5) && (j==1))
       return Interface.jButton51;
    if((i == 5) && (j==3))
       return Interface.jButton53;
    if((i == 5) && (j==5))
       return Interface.jButton55;
    if((i == 5) && (j==7))
       return Interface.jButton57;
    if((i == 6) && (j==0))
       return Interface.jButton60;
    if((i == 6) && (j==2))
       return Interface.jButton62;
    if((i == 6) && (j==4))
       return Interface.jButton64;
    if((i == 6) && (j==6))
       return Interface.jButton66;
    if((i == 7) && (j==1))
       return Interface.jButton71;
    if((i == 7) && (j==3))
       return Interface.jButton73;
    if((i == 7) && (j==5))
       return Interface.jButton75;
    if((i == 7) && (j==7))
       return Interface.jButton77;
    return null;
}

/*Função que recebe o tabuleiro e arruma como foi passado*/
public void formataJogada(char[][] tabuleiro){
    char[][] aux = new char[8][8];
    
    aux = formata_tabuleiro(tabuleiro);
    for (int i=0;i<aux.length;i++){
            for(int j = 0;j<aux[i].length;j++){
                if ( aux[i][j] == 'b')
                    setBotao(i,j).setIcon(Interface.azul.getIcon());
                else if (aux[i][j] == 'p')
                        setBotao(i,j).setIcon(Interface.vrmelha.getIcon());
                     else if (aux[i][j] == 'P')
                             setBotao(i,j).setIcon(Interface.damaVermelha.getIcon());
                          else if (aux[i][j] == 'B')
                                  setBotao(i,j).setIcon(Interface.damaAzul.getIcon());
                               else if (aux[i][j] == 'x')
                                      setBotao(i,j).setIcon(Interface.vazio.getIcon());
                                    //else{System.out.println("Deu nulo");}
            }
    }
 }


/*Coloca os espaços brancos no tabuleiro*/
private char[][] formata_tabuleiro(char[][] tabuleiro){
    char[][] formatado = new char[8][8];
    IA ia_ = new IA();

    formatado = ia_.copia_Tabuleiro(tabuleiro);
    for (int i=0;i<tabuleiro.length;i++){
        if ( i%2 == 0 ) {
            for(int j = 1;j<tabuleiro[i].length;j+=2){
              formatado[i][j] = '-';
            }
        }
        else{
            for(int j = 0;j<tabuleiro[i].length;j+=2){
              formatado[i][j] = '-';
            }
        }
    }
    return formatado;
}


public void jogada (JButton botao) {
    boolean fim, come = false;
    char[][] tab_aux, tab_ia, tab_auxiliar = new char[8][8];

    fim=Move(botao);
    int linha = Integer.parseInt(botao.getName().substring(7, 8));
    int coluna = Integer.parseInt(botao.getName().substring(8, 9));

    if (!fim) {
        k = 0;
        tab_auxiliar = ia.copia_Tabuleiro(tabuleiro);
        come =  BuscaVizinho(tab_auxiliar, "", linha, coluna, vetorCaminho);
    }
    if (come) {
        //System.out.print(vetorCaminho[0]);


       /* MelhorCaminho(viz, linha, coluna, vetorCaminho);
        System.out.print(viz[0][0].coluna);
        System.out.print(viz[0][0].coluna_adv);
        System.out.print(viz[0][0].linha);
        System.out.print(viz[0][0].linha_adv);*/
   }

    Virar_Dama(botao);
    if (fim && !come){
        VerificaVencedor();
        tab_aux=getTabuleiro();
        protocolo.Enviar_tabuleiro(tab_aux);
        VerificaVencedor();
        //Gambiarra do cabral
        ia.jogada_IA();

    //fim da gambiarra
        protocolo.Receber_tabuleiro(tab_aux);
        //if (tab_aux != tabuleiro) {
           setTabuleiro(tab_aux.clone());
           formataJogada(tabuleiro);

        //}
    }
        VerificaVencedor();
    }
     /*
     * PAREI AQUI!
     */
       public boolean BuscaVizinho(char [][] tabuleiro, String caminho, int i, int j, String[] vetor)

    {
        boolean fim = true;
        String aux_caminho = caminho;

            //Verifico SD ->i+1,j+1
            if ((i+2 < 8) && (j+2 < 8)) {
            if ((Character.toUpperCase(tabuleiro[i+1][j+1]) == 'P') &&(tabuleiro[i+2][j+2]=='x'))
            {
                CapturaLogica(tabuleiro,i,j,"SD");
                caminho = aux_caminho.concat("SD");
                fim = false;
                BuscaVizinho(tabuleiro,caminho,i+2,j+2,vetor);
            }}

             //Verifico SE ->i+1,j-1
            if ((i+2 < 8) && (j-2 >= 0)){
            if ((Character.toUpperCase(tabuleiro[i+1][j-1]) == 'P') &&(tabuleiro[i+2][j-2]=='x'))

            {
                CapturaLogica(tabuleiro,i,j,"SE");
                caminho = aux_caminho.concat("SE");
                fim = false;
                BuscaVizinho(tabuleiro,caminho,i+2,j-2,vetor);
            }}

            //Verifico ID ->i-1,j+1
            if ((i-2 >= 0) && (j+2 < 8)){
            if ((Character.toUpperCase(tabuleiro[i-1][j+1]) == 'P') &&(tabuleiro[i-2][j+2]=='x'))

            {
                CapturaLogica(tabuleiro,i,j,"ID");
                caminho = aux_caminho.concat("ID");
                fim = false;
                BuscaVizinho(tabuleiro,caminho,i-2,j+2,vetor);
            }}

            //Verifico IE ->i-1,j-1
            if ((i-2 >= 0) && (j-2 >= 0)){
            if ((Character.toUpperCase(tabuleiro[i-1][j-1]) == 'P') &&(tabuleiro[i-2][j-2]=='x'))

            {
                CapturaLogica(tabuleiro,i,j,"IE");
                caminho = aux_caminho.concat("IE");
                fim = false;
                BuscaVizinho(tabuleiro,caminho,i-2,j-2,vetor);
            }}

            if (fim)
            {
                vetor[k]=caminho; // K variavel global
                k = k + 1;
            }
        
        return !fim;

   }

    public void MelhorCaminho(Vizinho[][] caminhos, int i, int j, String[] vetor)

    {
        int m = 0;//int da matriz
        int p = 0;//int da matriz
        //int a = 0;//int da string

        int n = 1;
        int maior = vetor[0].length();

        String[] VetorMaior = new String[100];
        VetorMaior[0] = vetor[0];
        int k = 0;

        while (vetor[n]!=null)
        {
            if (vetor[n].length() > maior){
                VetorMaior = null;
                VetorMaior[0] = vetor[n];
                k =1;
            } else {
                if (vetor[n].length() == maior){
                    VetorMaior[k] = vetor[n];
                    k++;
                }
            }
            n = n + 1;
        }

        //Transformo a string nas linhas e colunas
        for (int l=0;l<=VetorMaior.length;i++){

            for (int a=0;a<=VetorMaior[l].length();a+=2)
            {
                //Armarmazeno os caminhos na matriz
                if (VetorMaior[l].substring(a, a+2).equals("SD"))
                {
                    caminhos[m][p].linha = i+2;
                    caminhos[m][p].coluna = j+2;
                    caminhos[m][p].linha_adv = i+1;
                    caminhos[m][p].coluna_adv = j+1;

                }else
                    {
                        if (VetorMaior[l].substring(a, a+2).equals("SE"))
                        {
                            caminhos[m][p].linha = i+2;
                            caminhos[m][p].coluna = j-2;
                            caminhos[m][p].linha_adv = i+1;
                            caminhos[m][p].coluna_adv = j-1;
                        }else
                            {
                                if(VetorMaior[l].substring(a, a+2).equals("ID"))
                                {
                                    caminhos[m][p].linha = i-2;
                                    caminhos[m][p].coluna = j+2;
                                    caminhos[m][p].linha_adv = i-1;
                                    caminhos[m][p].coluna_adv = j+1;
                                }else
                                    {
                                        caminhos[m][p].linha = i-2;
                                        caminhos[m][p].coluna = j-2;
                                        caminhos[m][p].linha_adv = i-1;
                                        caminhos[m][p].coluna_adv = j-1;
                                    }
                            }
                    }
                p = p+1;

            }//fim da palavra
            m++;
        }//Fim do vetor maior




    }

    public void CapturaLogica (char[][] tabuleiro,int i, int j, String tipo)

    {
        //SD
        if (tipo.equals("SD"))
        {
            tabuleiro[i+2][j+2] = 'b';
            tabuleiro[i+1][j+1] = 'x';
            tabuleiro[i][j] = 'x';
        }else
            {
                if (tipo.equals("SE"))
                {
                    tabuleiro[i+2][j-2] = 'b';
                    tabuleiro[i+1][j-1] = 'x';
                    tabuleiro[i][j] = 'x';
                }else
                    {
                        if (tipo.equals("ID"))
                        {
                            tabuleiro[i-2][j+2] = 'b';
                            tabuleiro[i-1][j+1] = 'x';
                            tabuleiro[i][j] = 'x';
                        }else
                            {
                                tabuleiro[i-2][j-2] = 'b';
                                tabuleiro[i-1][j-1] = 'x';
                                tabuleiro[i][j] = 'x';
                            }
                    }
                }
      }



    private void Captura(JButton botaoOri, JButton botaoDes/*,char[][]matriz, int linha_des, int coluna_des, Vizinho[][] caminhos, int linha_ori, int coluna_ori/*, int p, int m*/)
    {

        Interface inter = null;
        JButton botaoAdv = new JButton();
        int linha_des = Integer.parseInt(botaoDes.getName().substring(7, 8));
        int coluna_des = Integer.parseInt(botaoDes.getName().substring(8, 9));
        int linha_ori = Integer.parseInt(botaoOri.getName().substring(7, 8));
        int coluna_ori = Integer.parseInt(botaoOri.getName().substring(8, 9));
        //Botão do adversário
        int linha_adv = linha_des - linha_ori;
                if (linha_adv > 0) {

                     linha_adv = linha_ori + 1;
                    } else{

                         linha_adv = linha_ori - 1;

                    }

        int coluna_adv = coluna_des - coluna_ori;

        
                if (coluna_adv > 0) {

                        coluna_adv = coluna_ori + 1;
                }
        
                     else {

                        coluna_adv =coluna_ori - 1;
                     }


        //boolean correto = false;
        //if ((caminhos[m][p].linha==linha_des) && (caminhos[m][p].coluna==coluna_des))
        //{
            //correto = true;
            botaoDes.setIcon(botaoOri.getIcon());
            botaoOri.setIcon(Interface.vazio.getIcon());
            botaoAdv = setBotao(linha_adv,coluna_adv);
            botaoAdv.setIcon(Interface.vazio.getIcon());
            
            tabuleiro[linha_adv][coluna_adv] = ('x');
            tabuleiro[linha_des][coluna_des] = tabuleiro[linha_ori][coluna_ori];
            tabuleiro[linha_ori][coluna_ori] = ('x');
        //}
       /* if (p == 0 && !correto) {
            m++;
        }
        /*if (!correto)
            inter.Escreve("Nesta jogada existe um caminho melhor, tente de novo.");
*/
        //return correto;

    }



}








